home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume5 / rsed < prev    next >
Encoding:
Internet Message Format  |  1989-02-03  |  37.6 KB
  1. Path: xanth!nic.MR.NET!hal!ncoast!allbery
  2. From: doug@letni.UUCP (Doug Davis at letni.UUCP)
  3. Newsgroups: comp.sources.misc
  4. Subject: v05i082: rsed -- simple in-core editor
  5. Message-ID: <00001977-881112081327-346@letni.UUCP>
  6. Date: 14 Dec 88 03:01:09 GMT
  7. Sender: allbery@ncoast.UUCP
  8. Reply-To: doug@letni.UUCP (Doug Davis at letni.UUCP)
  9. Lines: 1477
  10. Approved: allbery@ncoast.UUCP
  11.  
  12. Posting-number: Volume 5, Issue 82
  13. Submitted-by: "Doug Davis at letni.UUCP" <doug@letni.UUCP>
  14. Archive-name: rsed
  15.  
  16. The attached shar file is source of a simple user-friendly(?) text file
  17. editor that I was commissioned to write for a bunch of computer illiterate's
  18. to edit mail messages.  The editor makes use of an in-memory linked list
  19. for storing each line, this gives it the ability to edit any size text
  20. file that a machine has user process space for.  I'm sending it to
  21. you to post, mostly because it shows a good simple example of using a linked
  22. list, as well as in the hopes that someone will take it further along 
  23. the evolutionary scale, and perhaps turn it into a real editor.
  24.  
  25. As usual I will gladly accept all of patches for suggested changes
  26. or porting problems. Flames however will cheerfully be ignored.
  27.  
  28. Doug Davis
  29. Lawnet
  30. 1030 Pleasent Valley Lane
  31. Arlington Texas 76015
  32. (817)-467-3740
  33.  
  34. { killer!texbell, sys1.tandy.com, lawnet, motown!sys1 } letni!doug
  35.  
  36.  
  37. #! /bin/sh
  38. # This is a shell archive.  Remove anything before this line, then unpack
  39. # it by saving it into a file and typing "sh file".  To overwrite existing
  40. # files, type "sh file -c".  You can also feed this as standard input via
  41. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  42. # will see the following message at the end:
  43. #        "End of archive 1 (of 1)."
  44. # Contents:  README rsedhelp Makefile defs.h externs.h command.c edit.c
  45. #   find.c globals.c input.c main.c mem.c multi.c stuff.c
  46. # Wrapped by doug@letni on Mon Dec 12 02:07:29 1988
  47. PATH=/bin:/usr/bin:/usr/local/bin:/usr/ucb ; export PATH
  48. if test -f 'README' -a "${1}" != "-c" ; then 
  49.   echo shar: Will not clobber existing file \"'README'\"
  50. else
  51. echo shar: Extracting \"'README'\" \(3961 characters\)
  52. sed "s/^X//" >'README' <<'END_OF_FILE'
  53. X
  54. Real Simple Ed 
  55. X
  56. Rsed is a real simple editor program designed for people who are calling
  57. into a machine to be able to edit files on a variaty of differen't 
  58. terminals and/or computers WITHOUT haveing to learn an editor.  Rsed
  59. is very easy to use and tries to be as "user friendly" as possable.
  60. X
  61. Defines:
  62. WSEDHELP          Where the help file resieds.
  63. MAXREPLACE        malloc size for the replacement string
  64. BEGINDOTS         size of file to warrent nifty-userfriendly dots to show
  65. X                  that we are doing something.
  66. X
  67. Options:
  68. X    -a ##    load file and append after line ##
  69. X    -w         write the file out when you quit the editor (silent)
  70. X    -D        debug (used for fiddling with the linked list)
  71. X
  72. X
  73. Porting:
  74. X    rsed usese curses just for turning off echo and setting crmod, 
  75. X    if you don't want to fool with that, or don't have curses you will
  76. X    have to fix up your own terminal handler. The following are the
  77. X    function calls to worry about.
  78. X        savetty() save the current modes of the terminal for later recall
  79. X        initscr() sets up curses.
  80. X        crmode()  puts the terminal into One Charicter At A Time mode.
  81. X        resetty() restores the previously saved tty information.
  82. X    
  83. X    rsed also uses getopt() most later version unix's have this, if
  84. X    yours does not, a public domain version of it is available thru
  85. X    comp.sources.unix.
  86. X    
  87. X    Othewise rsed has been known to compile without changes on 4.1 BSD (vax),
  88. X    4.2 BSD (vax) 4.3 BSD (vax), Ultrix (vax) sco (%d86) micro, Tandy 6000,
  89. X    Masscomp, NCR tower, ATT 3b2 and a logic processes Mpulse. So it ought
  90. X    to compile on yours.  If your compiler can't handle macros you will
  91. X    need to work on the RANGE marco in multi.c.  Otherwise
  92. X    please let me know of any problems and may the source be with you %s.
  93. X
  94. X
  95. Author:
  96. X    Douglas L. Davis
  97. X    (Lawnet, Texas R&D office)
  98. X    1030 Pleasent Valley Lane
  99. X    Arlington Texas  76015
  100. X    (817)-467-3740
  101. X    { sys1 || texbell || lawnet }!letni!doug
  102. X    
  103. X
  104. XFunction call        Description
  105. main            Main routine, parses args, calls edit.
  106. add             adds a char array below line number specified.
  107. append          asks user for lines to add().
  108. boom            debug sigint routine.
  109. change          asks user for a replacement line.
  110. clear_stuff     frees the entire linked list.
  111. command         does the command prompting
  112. edit            if nessasary creates the file, then loads it.
  113. find            returns a line with a pre-specified string
  114. getline         returns a LINE pointer for the specified line number.
  115. getlineno       gets a line number from the tty.
  116. getstring       gets a string from the tty.
  117. global_replace  replaces a specified string with another full file.
  118. go_fish         asks user for a search string then calls find with it.
  119. go_global       asks user for a search string and a replacement string.
  120. help            concatinate the rsedhelp file.
  121. insert          asks user for a line.
  122. loadem          reads a file into the editor buffer.
  123. makenum         convert a string to a numeric entry.
  124. printline       prints a line out of the editor.
  125. replace         replace the text of a specified line with a user buf
  126. reset_find      clears the global search stuff.
  127. saveem          saves the editor buf to a file.
  128. setfind         sets up the global search stuff.
  129. setline         set the current line to a specified line number.
  130. srch_n_replace  do a search / replace within a (LINE *) struct
  131. srchrep         user interface for srch_n_replace.
  132. strappend       like strcat() but returns then end of it's string.
  133. strindex        returns a pointer to a string found in another string.
  134. subtract        removes a spacified line from the buffer.
  135. yesno           asks for a yes or no answer from the user.
  136. multi_print     ask for starting line / ending line then for()'s printline()
  137. multi_delete    ask for starting line / ending line then for()'s subtract()
  138. multi_change    ask for starting line / ending line then for()'s change()
  139. END_OF_FILE
  140. if test 3961 -ne `wc -c <'README'`; then
  141.     echo shar: \"'README'\" unpacked with wrong size!
  142. fi
  143. # end of 'README'
  144. fi
  145. if test -f 'rsedhelp' -a "${1}" != "-c" ; then 
  146.   echo shar: Will not clobber existing file \"'rsedhelp'\"
  147. else
  148. echo shar: Extracting \"'rsedhelp'\" \(1086 characters\)
  149. sed "s/^X//" >'rsedhelp' <<'END_OF_FILE'
  150. X
  151. X  Keys             Action
  152. X ------          ---------
  153. X [0-9]  .........change the current line.
  154. X   $    .........go to the bottom of the file.
  155. X   ^    .........go to the top of the file.
  156. X+ or ;  .........advance to the next line.
  157. X   -    .........backup to the previous line.
  158. X   a    .........append text after the current line.
  159. X   c    .........change (i.e. replace) the current line.
  160. X   d    .........delete (i.e. remove) the current line.
  161. f or /  .........find and advance to a line with a specified string.
  162. X   g    .........global replacement (entire file) of a string with another.
  163. X   i    .........insert text before the current line.
  164. X   n    .........advance to the next occurence of a string (re: f option)
  165. X   p    .........print (i.e. display) the current line.
  166. X   q    .........quit the editor.
  167. X   s    .........search and replace a string on the current line.
  168. X   w    .........write out all changes.
  169. X   P    .........asks for and then prints a range of lines.
  170. X   ?    .........display this file.
  171. X
  172. Note: input(s) can be ended or aborted by entering a '.' on a line by itself.
  173. END_OF_FILE
  174. if test 1086 -ne `wc -c <'rsedhelp'`; then
  175.     echo shar: \"'rsedhelp'\" unpacked with wrong size!
  176. fi
  177. # end of 'rsedhelp'
  178. fi
  179. if test -f 'Makefile' -a "${1}" != "-c" ; then 
  180.   echo shar: Will not clobber existing file \"'Makefile'\"
  181. else
  182. echo shar: Extracting \"'Makefile'\" \(960 characters\)
  183. sed "s/^X//" >'Makefile' <<'END_OF_FILE'
  184. X# in an '86 environment this better be compiled in large model
  185. SHELL=/bin/sh
  186. X
  187. X# defines for curses that needs termcap BSD,  xenix,  etc....
  188. X# CURSNAME  = -lcurses -ltermlib
  189. X# CURSNAME    = -lcurses -ltermcap
  190. X# defines for sysV curses needs cbreak() function call.
  191. X# if yours has crmode() instead, you will have to hack defs.h
  192. X# CURSNAME    = -lcurses 
  193. X
  194. X# if your machine has strchr
  195. X# DEFINES=-DSTRCHR=strchr
  196. X# if your machine has index / rindex
  197. X# DEFINES=-DSTRCHR=index
  198. X
  199. X 
  200. X# for 286 uncomment the line below
  201. X# CFLAGS    =    -O -AL $(DEFINES)
  202. X# LDFLAGS =    -AL -i
  203. X# for most other systems
  204. X# CFLAGS    =    -O $(DEFINES)
  205. X# LDFLAGS    =    -n
  206. OBJECTS =    globals.o main.o mem.o command.o edit.o input.o stuff.o \
  207. X        find.o multi.o
  208. CC=/bin/cc
  209. X
  210. all: rsed
  211. X
  212. rsed:    ${OBJECTS}
  213. X        $(CC) ${LDFLAGS} ${OBJECTS} -o rsed $(CURSNAME)
  214. X
  215. tags: *.h *.c
  216. X    ctags *.h *.c
  217. X
  218. shar:
  219. X    shar -n 1 -e 1 -t 'Now read the README file and edit the Makefile for your system' \
  220. X        README rsedhelp Makefile *.h *.c > rsed.shar
  221. END_OF_FILE
  222. if test 960 -ne `wc -c <'Makefile'`; then
  223.     echo shar: \"'Makefile'\" unpacked with wrong size!
  224. fi
  225. # end of 'Makefile'
  226. fi
  227. if test -f 'defs.h' -a "${1}" != "-c" ; then 
  228.   echo shar: Will not clobber existing file \"'defs.h'\"
  229. else
  230. echo shar: Extracting \"'defs.h'\" \(984 characters\)
  231. sed "s/^X//" >'defs.h' <<'END_OF_FILE'
  232. X/*
  233. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  234. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  235. X *  any maner provided you give credit where credit is due and don't pretend
  236. X *  you wrote it.
  237. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  238. X *  in copyright law that you will never ever forget.
  239. X */
  240. X#include <sys/types.h>
  241. X#include <signal.h>
  242. X#include <fcntl.h>
  243. X#include <ctype.h>
  244. X#include <sys/stat.h>
  245. X#include <stdio.h>
  246. X#include <errno.h>
  247. X#include "curses.h"
  248. X
  249. X#define WSEDHELP    "/usr/lib/rsedhelp";
  250. X#define    MAXREPLACE    4096 /* biggest tmp line size for global replacement */
  251. X#define    BEGINDOTS    24L * 1024L /* size of file to warrent dots to show
  252. X                    that we are doing something */
  253. X
  254. typedef struct line {
  255. X    struct line *previous;
  256. X    struct line *next;
  257. X    char text[1]; /* has to be end */
  258. X} LINE;
  259. X
  260. X#ifndef MSDOS
  261. X    #ifdef CBREAK
  262. X    #define One_Char()    crmode();
  263. X    #else
  264. X    #define One_Char()    cbreak();
  265. X    #endif
  266. X#endif MSDOS
  267. END_OF_FILE
  268. if test 984 -ne `wc -c <'defs.h'`; then
  269.     echo shar: \"'defs.h'\" unpacked with wrong size!
  270. fi
  271. # end of 'defs.h'
  272. fi
  273. if test -f 'externs.h' -a "${1}" != "-c" ; then 
  274.   echo shar: Will not clobber existing file \"'externs.h'\"
  275. else
  276. echo shar: Extracting \"'externs.h'\" \(1116 characters\)
  277. sed "s/^X//" >'externs.h' <<'END_OF_FILE'
  278. X
  279. X/*
  280. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  281. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  282. X *  any maner provided you give credit where credit is due and don't pretend
  283. X *  you wrote it.
  284. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  285. X *  in copyright law that you will never ever forget.
  286. X */
  287. extern    FILE    *EditFile;
  288. extern    LINE    *current;
  289. extern    LINE    *find_work;
  290. extern    LINE    *getline();
  291. extern    LINE    *l_end;
  292. extern    LINE    *l_start;
  293. extern    LINE    *setline();
  294. extern    char    *Bottom;
  295. extern    char    *Eof;
  296. extern    char    *HelpName;
  297. extern    char    *Progname;
  298. extern    char    *STRCHR();
  299. extern    char    *Top;
  300. extern    char    *find_string;
  301. extern    char    *getstring();
  302. extern    char    *malloc();
  303. extern    char    *strappend();
  304. extern    char    *strindex();
  305. extern    char    Dots;
  306. extern    char    WriteOnQuit;
  307. extern    char    buf[BUFSIZ];
  308. extern    char    yesno();
  309. extern    int    Debug;
  310. extern    int    errno;
  311. extern    int    getopt();
  312. extern    long    CurrentLine;
  313. extern    long    NumberLines;
  314. extern    long    atol();
  315. extern    long    find();
  316. extern    long    find_line;
  317. extern    long    getlineno();
  318. extern    long    loadem();
  319. extern    long    makenum();
  320. END_OF_FILE
  321. if test 1116 -ne `wc -c <'externs.h'`; then
  322.     echo shar: \"'externs.h'\" unpacked with wrong size!
  323. fi
  324. # end of 'externs.h'
  325. fi
  326. if test -f 'command.c' -a "${1}" != "-c" ; then 
  327.   echo shar: Will not clobber existing file \"'command.c'\"
  328. else
  329. echo shar: Extracting \"'command.c'\" \(4136 characters\)
  330. sed "s/^X//" >'command.c' <<'END_OF_FILE'
  331. X
  332. X/*
  333. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  334. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  335. X *  any maner provided you give credit where credit is due and don't pretend
  336. X *  you wrote it.
  337. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  338. X *  in copyright law that you will never ever forget.
  339. X */
  340. X#include "defs.h"
  341. X#include "externs.h"
  342. X
  343. command(file, sline)
  344. char *file;
  345. char *sline;
  346. X{
  347. X    char c;
  348. X    long start;
  349. X    char changed='N';
  350. X    if (*sline != '\0') {
  351. X        start=makenum(sline);
  352. X        fputs("appending ", stdout);
  353. X        if (start >= NumberLines) 
  354. X            fputs("to the bottom", stdout);
  355. X        else 
  356. X            printf("below line %ld", start);
  357. X        puts(", enter text now:");
  358. X        append(start <= NumberLines ? start : NumberLines);
  359. X        start=NumberLines;
  360. X    } else
  361. X        start = 1L;
  362. X    
  363. X    if (NumberLines > 0L)
  364. X        setline(start);
  365. X    for (;;) {
  366. X        if (NumberLines < 1L || CurrentLine < 1L) {
  367. X            puts("Buffer empty, begin entering new text.");
  368. X            append(0L);
  369. X            continue;
  370. X        }
  371. X        if (Debug) {
  372. X            printf("address             l_start: 0x%lx\n",
  373. X                l_start);
  374. X            printf("address             current: 0x%lx\n",
  375. X                current);
  376. X            printf("address               l_end: 0x%lx\n",
  377. X                l_end);
  378. X            printf("address l_start -> previous: 0x%lx\n", 
  379. X                l_start->previous);
  380. X            printf("address       l_end -> next: 0x%lx\n",
  381. X                l_end->next);
  382. X        }
  383. X        printf("Line %ld>", CurrentLine);
  384. X#ifdef MSDOS
  385. X        c=getch();
  386. X#else 
  387. X        c=getchar();
  388. X#endif MSDOS
  389. X        switch(c) {
  390. X            case '0':
  391. X            case '1':
  392. X            case '2':
  393. X            case '3':
  394. X            case '4':
  395. X            case '5':
  396. X            case '6':
  397. X            case '7':
  398. X            case '8':
  399. X            case '9':
  400. X                fputs("Enter new line :", stdout);
  401. X                getstring(buf, 10, c);
  402. X                if ((start=makenum(buf)) > 0L && 
  403. X                        start <= NumberLines) {
  404. X                    if (setline(start) == (LINE *) NULL) 
  405. X                        puts("Sorry..");
  406. X                }
  407. X                break;
  408. X            case '+':
  409. X            case ';':
  410. X                putchar('\n');
  411. X                if (CurrentLine < NumberLines) {
  412. X                    CurrentLine++;
  413. X                    printline(CurrentLine);
  414. X                } else
  415. X                    puts(Bottom);
  416. X                break;
  417. X            case '-':
  418. X                putchar('\n');
  419. X                if (CurrentLine > 1) {
  420. X                    CurrentLine--;
  421. X                    printline(CurrentLine);
  422. X                } else 
  423. X                    puts(Top);
  424. X                break;
  425. X            case '$':
  426. X                putchar('\n');
  427. X                CurrentLine = NumberLines;
  428. X                setline(CurrentLine);
  429. X                puts(Bottom);
  430. X                break;
  431. X            case '^':
  432. X                putchar('\n');
  433. X                CurrentLine = 1L;
  434. X                setline(CurrentLine);
  435. X                puts(Top);
  436. X                break;
  437. X            case 'C':
  438. X                puts("Change lines.");
  439. X                multi_change();
  440. X                changed = 'Y';
  441. X                break;
  442. X            case 'D':
  443. X                puts("Delete lines.");
  444. X                multi_delete();
  445. X                changed = 'Y';
  446. X                break;
  447. X            case 'P':
  448. X                puts("Print.");
  449. X                multi_print();
  450. X                break;
  451. X            case 'a':
  452. X                printf("Appending after line # %ld\n", CurrentLine);
  453. X                append(CurrentLine);
  454. X                changed = 'Y';
  455. X                break;
  456. X            case 'c':
  457. X                printf("Change line # %ld\n", CurrentLine);
  458. X                change(CurrentLine);
  459. X                changed = 'Y';
  460. X                break;
  461. X            case 'd':
  462. X                printf("Deleted line # %ld\n", CurrentLine);
  463. X                subtract(CurrentLine);
  464. X                changed = 'Y';
  465. X                break;
  466. X            case 'f':
  467. X            case '/':
  468. X                puts("Find string.");
  469. X                go_fish(CurrentLine);
  470. X                break;
  471. X            case 'g':
  472. X                puts("Global.");
  473. X                go_global(CurrentLine);
  474. X                changed = 'Y';
  475. X                break;
  476. X            case 'i':
  477. X                printf("Inserting before line %ld.\n", CurrentLine);
  478. X                insert(CurrentLine);
  479. X                changed = 'Y';
  480. X                break;
  481. X            case 'n': /* next occurence */
  482. X                puts("Next.");
  483. X                find('v');
  484. X                break;
  485. X            case 'p':
  486. X                puts("print.");
  487. X                printline(CurrentLine);
  488. X                break;
  489. X            case 'q':
  490. X                puts("quit.");
  491. X                if (WriteOnQuit == 'Y') {
  492. X                    if(saveem(file) == OK) {
  493. X                        return(OK);
  494. X                    } else {
  495. X                        fprintf(stderr, "%s: Write on quit set, but save failed.\n", Progname);
  496. X                        WriteOnQuit='N';
  497. X                        break;
  498. X                    }
  499. X                    
  500. X                }
  501. X                if (changed == 'Y') {
  502. X                    fputs("File changed, are you sure (y/n) ? ", stdout);
  503. X                    c=yesno();
  504. X                    if (c == 'N') 
  505. X                        break;
  506. X                }
  507. X                return(OK);
  508. X                break;
  509. X            case 's':
  510. X                puts("search/replace");
  511. X                srchrep(CurrentLine);
  512. X                changed = 'Y';
  513. X                break;
  514. X            case 'w':
  515. X                puts("Saveing.");
  516. X                saveem(file);
  517. X                changed = 'N';
  518. X                break;
  519. X            case '?':
  520. X                puts("Help.");
  521. X                help();
  522. X                break;
  523. X            default:
  524. X                puts("? - for help");
  525. X                break;
  526. X                
  527. X        }
  528. X    }
  529. X}
  530. END_OF_FILE
  531. if test 4136 -ne `wc -c <'command.c'`; then
  532.     echo shar: \"'command.c'\" unpacked with wrong size!
  533. fi
  534. # end of 'command.c'
  535. fi
  536. if test -f 'edit.c' -a "${1}" != "-c" ; then 
  537.   echo shar: Will not clobber existing file \"'edit.c'\"
  538. else
  539. echo shar: Extracting \"'edit.c'\" \(2656 characters\)
  540. sed "s/^X//" >'edit.c' <<'END_OF_FILE'
  541. X
  542. X/*
  543. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  544. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  545. X *  any maner provided you give credit where credit is due and don't pretend
  546. X *  you wrote it.
  547. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  548. X *  in copyright law that you will never ever forget.
  549. X */
  550. X#include "defs.h"
  551. X#include "externs.h"
  552. X
  553. append(number)
  554. long number;
  555. X{
  556. X    puts("Enter a single period on a blank line to return to the editor");
  557. X    for (;;number++) {
  558. X        getstring(buf, BUFSIZ, '\0');
  559. X        if (*buf == '.' && strlen(buf) == 1) 
  560. X            return(OK);
  561. X        add(buf, number);
  562. X    }
  563. X}
  564. X        
  565. change(number)
  566. long number;
  567. X{
  568. X    printf("Currently line %ld looks like:\n", number);
  569. X    printline(number);
  570. X    printf("Type the new line %ld\n", number);
  571. X    getstring(buf, BUFSIZ, '\0');
  572. X    if (*buf == '.' && strlen(buf) == 1)  {
  573. X        puts("Aborted.");
  574. X        return(!OK);
  575. X    }
  576. X    return(replace(number, buf));
  577. X}
  578. srchrep(number)
  579. long number;
  580. X{
  581. X    char old[81], new[81], c='\0';
  582. X    printf("Line %ld looks like :\n", number);
  583. X    printline(number);
  584. X    fputs("     Search string: ", stdout);
  585. X    if (getstring(old, 81, '\0') == NULL)
  586. X        return(!OK);
  587. X    fputs("Replacement string: ", stdout);
  588. X    if (getstring(new, 81, '\0') == NULL)
  589. X        return(!OK);
  590. X    while (c != 'N' && c != 'Y') {
  591. X        fputs("Global replacement? ", stdout);
  592. X        c=getchar();
  593. X        if (islower(c)) 
  594. X            c=toupper(c);
  595. X        if (c == '\n') 
  596. X            c='N';
  597. X        switch(c) {
  598. X            case 'N':
  599. X                puts("No.");
  600. X            break;
  601. X            case 'Y':
  602. X                puts("Yes.");
  603. X            break;
  604. X            case 'Q':
  605. X                return(!OK);
  606. X            break;
  607. X            default:
  608. X                fputs("\007<Y>es, <N>o or <Q>uit please.\n", stdout);
  609. X            break;
  610. X        }
  611. X    }
  612. X    srch_n_replace(number, old, new, c);
  613. X    printline(number);
  614. X    return(OK);
  615. X}
  616. go_fish(number)
  617. long number;
  618. X{
  619. X    char sstring[81];
  620. X    fputs("String to search for : ", stdout);
  621. X    if(getstring(sstring, 80, '\0') == NULL)
  622. X        return(!OK);
  623. X    if (setfind(number, sstring) == OK) 
  624. X        return(find('v') > 0L ? OK : !OK);
  625. X    return(!OK);
  626. X}
  627. go_global(number)
  628. long number;
  629. X{
  630. X    char old[81], new[81];
  631. X    fputs("     Search string: ", stdout);
  632. X    if (getstring(old, 80, '\0') == NULL)
  633. X        return(!OK);
  634. X    fputs("Replacement string: ", stdout);
  635. X    if (getstring(new, 80, '\0') == NULL)
  636. X        return(!OK);
  637. X    return(global_replace(number, old, new));
  638. X}
  639. global_replace(number, old, new)
  640. long number;
  641. char *old, *new;
  642. X{
  643. X    long line, count=0L;
  644. X    if (setfind(number, old) == OK) {
  645. X        while ((line=find('n')) > 0L)  {
  646. X            if (srch_n_replace(line, old, new, 'Y') == OK) 
  647. X                count++;
  648. X        }
  649. X        printf("Replaced \"%s\" with \"%s\" %ld times.\n",
  650. X            old, new, count);
  651. X
  652. X        return(count > 0L ? OK : !OK);
  653. X    }
  654. X    return(!OK);
  655. X}
  656. insert(number)
  657. long number;
  658. X{
  659. X    number--;
  660. X    return(append(number));
  661. X}
  662. END_OF_FILE
  663. if test 2656 -ne `wc -c <'edit.c'`; then
  664.     echo shar: \"'edit.c'\" unpacked with wrong size!
  665. fi
  666. # end of 'edit.c'
  667. fi
  668. if test -f 'find.c' -a "${1}" != "-c" ; then 
  669.   echo shar: Will not clobber existing file \"'find.c'\"
  670. else
  671. echo shar: Extracting \"'find.c'\" \(1349 characters\)
  672. sed "s/^X//" >'find.c' <<'END_OF_FILE'
  673. X
  674. X/*
  675. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  676. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  677. X *  any maner provided you give credit where credit is due and don't pretend
  678. X *  you wrote it.
  679. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  680. X *  in copyright law that you will never ever forget.
  681. X */
  682. X#include "defs.h"
  683. X#include "externs.h"
  684. X
  685. X#define __FILE__    "find.c"
  686. X
  687. long
  688. find(c)
  689. char c;
  690. X{
  691. X    if (find_work == (LINE *) NULL || find_line >= NumberLines) {
  692. X        puts(Eof);
  693. X        reset_find();
  694. X        return(-1L);
  695. X    }
  696. X    while (find_work != (LINE *) NULL) {
  697. X        if (strindex(find_work->text, find_string) != NULL) {
  698. X            CurrentLine=find_line;
  699. X            if (c == 'v') printline(CurrentLine);
  700. X            find_work = find_work -> next;
  701. X            find_line++;
  702. X            return(CurrentLine);
  703. X        }
  704. X        find_work = find_work -> next;
  705. X        find_line++;
  706. X    }
  707. X    puts(Eof);
  708. X    return(-1L);
  709. X}
  710. reset_find()
  711. X{
  712. X    find_work = l_start;
  713. X    find_line = 1L;
  714. X}
  715. setfind(number, string)
  716. long number;
  717. char *string;
  718. X{
  719. X    if (find_string != NULL)
  720. X        free(find_string);
  721. X    find_string = malloc(strlen(string) + 1);
  722. X    if (find_string == NULL) {
  723. X        fprintf(stderr, "%s: malloc(%d) failed\n", __FILE__,
  724. X                strlen(string));
  725. X        return(!OK);
  726. X    }
  727. X    strcpy(find_string, string);
  728. X    find_line = number;
  729. X    find_work = setline(find_line);
  730. X    return(find_work != (LINE *) NULL ? OK : !OK);
  731. X}
  732. END_OF_FILE
  733. if test 1349 -ne `wc -c <'find.c'`; then
  734.     echo shar: \"'find.c'\" unpacked with wrong size!
  735. fi
  736. # end of 'find.c'
  737. fi
  738. if test -f 'globals.c' -a "${1}" != "-c" ; then 
  739.   echo shar: Will not clobber existing file \"'globals.c'\"
  740. else
  741. echo shar: Extracting \"'globals.c'\" \(834 characters\)
  742. sed "s/^X//" >'globals.c' <<'END_OF_FILE'
  743. X
  744. X/*
  745. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  746. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  747. X *  any maner provided you give credit where credit is due and don't pretend
  748. X *  you wrote it.
  749. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  750. X *  in copyright law that you will never ever forget.
  751. X */
  752. X#include "defs.h"
  753. X
  754. XFILE    *EditFile;
  755. LINE    *current    = (LINE *) NULL;
  756. LINE    *find_work    = (LINE *) NULL;
  757. LINE    *l_end        = (LINE *) NULL;
  758. LINE    *l_start    = (LINE *) NULL; 
  759. char    *Bottom="Bottom of file.";
  760. char    *Eof="Search ending, bottom of file.";
  761. char    *Progname;
  762. char    *Top="Top of file.";
  763. char    *find_string = NULL;
  764. char    Dots        = 'N';
  765. char    WriteOnQuit    = 'N';
  766. char    buf[BUFSIZ];
  767. int    Debug;
  768. long    CurrentLine;
  769. long    NumberLines;
  770. long    find_line = 1L;
  771. char    *HelpName=WSEDHELP;
  772. END_OF_FILE
  773. if test 834 -ne `wc -c <'globals.c'`; then
  774.     echo shar: \"'globals.c'\" unpacked with wrong size!
  775. fi
  776. # end of 'globals.c'
  777. fi
  778. if test -f 'input.c' -a "${1}" != "-c" ; then 
  779.   echo shar: Will not clobber existing file \"'input.c'\"
  780. else
  781. echo shar: Extracting \"'input.c'\" \(1511 characters\)
  782. sed "s/^X//" >'input.c' <<'END_OF_FILE'
  783. X
  784. X/*
  785. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  786. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  787. X *  any maner provided you give credit where credit is due and don't pretend
  788. X *  you wrote it.
  789. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  790. X *  in copyright law that you will never ever forget.
  791. X */
  792. X#include "defs.h"
  793. X#include "externs.h"
  794. X
  795. long
  796. getlnum()
  797. X{
  798. X    getstring(buf, 10, '\0');
  799. X    return(makenum(buf));
  800. X}
  801. X
  802. char
  803. yesno()
  804. X{
  805. X    char c;
  806. X    for (;;) {
  807. X#ifdef MSDOS
  808. X        c=getch();
  809. X#else MSDOS
  810. X        c=getchar();
  811. X#endif MSDOS
  812. X        if (islower(c))
  813. X            c=toupper(c);
  814. X        switch (c) {
  815. X            case 'Y':
  816. X                puts("Yes.");
  817. X                return(c);
  818. X            break;
  819. X            case 'N':
  820. X                puts("No.");
  821. X                return(c);
  822. X            break;
  823. X            default:
  824. X                puts("<Y>es or <N>o please.");
  825. X            break;
  826. X        }
  827. X    }
  828. X}
  829. X/*
  830. X *    This routine gets a string..
  831. X *
  832. X */
  833. char *
  834. getstring(str, len, first)
  835. char    *str;
  836. int    len;
  837. char    first;
  838. X{
  839. X    char *p, c;
  840. X    p = str;
  841. X    if (first != '\0')  {
  842. X        *(p++) = first;
  843. X        putchar(first);
  844. X    }        
  845. X    for ( ;; ) {
  846. X#ifdef MSDOS
  847. X        c = getch();
  848. X#else
  849. X        c = getchar();
  850. X#endif MSDOS
  851. X        switch(c) {
  852. X            case '\b': {
  853. X                if (p > str) {
  854. X                    *p='\0';
  855. X                    fputs("\010 \010", stdout);
  856. X                    *(p--)='\0';
  857. X                } else {
  858. X                    putchar('\007');
  859. X                    }
  860. X                }
  861. X                break;
  862. X            case '\n':
  863. X            case '\r': {
  864. X                *p='\0';
  865. X                putchar('\n');
  866. X                return(*str != '\0' ? str : NULL);
  867. X                } break;
  868. X            default: {
  869. X                if (p < str+len) {
  870. X                    *(p++) = c;
  871. X                    putchar(c);
  872. X                } else { 
  873. X                    putchar('\007');
  874. X                }
  875. X            } break;
  876. X        }
  877. X    }
  878. X}
  879. END_OF_FILE
  880. if test 1511 -ne `wc -c <'input.c'`; then
  881.     echo shar: \"'input.c'\" unpacked with wrong size!
  882. fi
  883. # end of 'input.c'
  884. fi
  885. if test -f 'main.c' -a "${1}" != "-c" ; then 
  886.   echo shar: Will not clobber existing file \"'main.c'\"
  887. else
  888. echo shar: Extracting \"'main.c'\" \(2419 characters\)
  889. sed "s/^X//" >'main.c' <<'END_OF_FILE'
  890. X
  891. X/*
  892. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  893. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  894. X *  any maner provided you give credit where credit is due and don't pretend
  895. X *  you wrote it.
  896. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  897. X *  in copyright law that you will never ever forget.
  898. X */
  899. X#include "defs.h"
  900. X#include "externs.h"
  901. X
  902. main(argc, argv)
  903. int argc;
  904. char **argv;
  905. X{
  906. X    int c;
  907. X    char start_line[80];
  908. X    extern char *optarg;
  909. X    extern int optind, opterr;
  910. X    opterr=1;
  911. X    Progname = *argv;
  912. X#ifndef MSDOS
  913. X    savetty();
  914. X    initscr();
  915. X#endif MSDOS
  916. X    signal(SIGINT, SIG_IGN);
  917. X    while ((c=getopt(argc, argv, "Dwa:")) != EOF) {
  918. X        switch (c) {
  919. X        case 'D': Debug = 1;            break;
  920. X        case 'a': strcpy(start_line,optarg);    break;
  921. X        case 'w': WriteOnQuit='Y';        break;
  922. X        }
  923. X    }
  924. X    if (Debug) printf("extra args %d\n", optind);
  925. X    if (argc < 2) {
  926. X        fprintf(stderr, "%s: usage: %s [options] file [ file file]\n",
  927. X                Progname, Progname);
  928. X        exit(-1);
  929. X    }
  930. X    for (;optind < argc; optind++) {
  931. X        errno=0;
  932. X        edit(argv[optind], start_line);
  933. X        *start_line = '\0';
  934. X    }
  935. X    resetty();
  936. X    exit(errno);
  937. X}
  938. X
  939. edit(file, sline)
  940. char *file;
  941. char *sline;
  942. X{
  943. X    struct stat stbuff, *s;
  944. X    char c;
  945. X    int new=!OK;
  946. X    s=(struct stat *) &stbuff;
  947. X    clear_stuff();
  948. X    noecho();
  949. X    One_Char();
  950. X    if ((EditFile=fopen(file, "r")) == (FILE *) NULL) {
  951. X        if (errno == ENOENT) {
  952. X            printf("File %s doesn't exist, create (y/n) ? ",
  953. X                file);
  954. X            c=yesno();
  955. X            switch(c) {
  956. X                case 'Y':
  957. X                    close(creat(file, 0666));
  958. X                    if ((EditFile=fopen(file, "r")) == (FILE *) NULL) {
  959. X                        /* give up... */
  960. X                        fprintf(stderr, "%s: could not create %s\n", Progname, file);
  961. X                        return(!OK);
  962. X                    }
  963. X                    new=OK;
  964. X                    break;
  965. X                case 'N':
  966. X                default:
  967. X                    return(OK);
  968. X                    break;    
  969. X            }
  970. X        } else {
  971. X        fprintf(stderr, "%s: Could not read %s",
  972. X            Progname, file);
  973. X            perror("");
  974. X            return(!OK);
  975. X        }
  976. X    }
  977. X    if (fstat(fileno(EditFile), s) < 0) {
  978. X        fprintf(stderr, "%s: fstat(%d) failed",
  979. X            Progname, fileno(EditFile));
  980. X            perror("");
  981. X            return(!OK);
  982. X        }
  983. X    if (s->st_size > BEGINDOTS)
  984. X        Dots = 'Y';
  985. X    if (new != OK && s->st_size > 0L)  {
  986. X        if (loadem(EditFile, 0L) > 0L) {
  987. X            printf("File: \"%s\"   lines=%ld, charicters=%ld\n",
  988. X                file, NumberLines, s->st_size);
  989. X            fclose(EditFile);
  990. X            command(file, sline);
  991. X        }
  992. X    } else {
  993. X        printf("File: \"%s\" is new, begin entering new text\n", file);
  994. X        append(0L);
  995. X        command(file, "\0");
  996. X    }
  997. X    return(OK);
  998. X}
  999. END_OF_FILE
  1000. if test 2419 -ne `wc -c <'main.c'`; then
  1001.     echo shar: \"'main.c'\" unpacked with wrong size!
  1002. fi
  1003. # end of 'main.c'
  1004. fi
  1005. if test -f 'mem.c' -a "${1}" != "-c" ; then 
  1006.   echo shar: Will not clobber existing file \"'mem.c'\"
  1007. else
  1008. echo shar: Extracting \"'mem.c'\" \(5810 characters\)
  1009. sed "s/^X//" >'mem.c' <<'END_OF_FILE'
  1010. X    
  1011. X/*
  1012. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  1013. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  1014. X *  any maner provided you give credit where credit is due and don't pretend
  1015. X *  you wrote it.
  1016. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  1017. X *  in copyright law that you will never ever forget.
  1018. X */
  1019. X#include "defs.h"
  1020. X#include "externs.h"
  1021. X
  1022. X#define __FILE__    "mem.c"
  1023. X
  1024. clear_stuff()
  1025. X{
  1026. X    LINE *temp, *next;
  1027. X    if (l_start != (LINE *) NULL) {
  1028. X        /* something inside, clear 'em out */
  1029. X        for (temp = l_end; temp != l_start ;) {
  1030. X            next = temp->previous;
  1031. X            free(temp);
  1032. X            temp = next;
  1033. X        }
  1034. X    }
  1035. X    l_start = (LINE *) malloc(sizeof(LINE) + 2);
  1036. X    l_start -> previous     = (LINE *) NULL;
  1037. X    l_start -> next        = (LINE *) NULL;
  1038. X    l_end             = l_start;
  1039. X    current            = l_start;
  1040. X    CurrentLine        = 0L;
  1041. X    NumberLines        = 0L;
  1042. X}
  1043. long
  1044. loadem(inputfile, place)
  1045. XFILE *inputfile;
  1046. long place;
  1047. X{
  1048. X    while ((fgets(buf, BUFSIZ, inputfile)) != NULL) {
  1049. X        if(add(buf, place++) != OK) {
  1050. X            fprintf(stderr, "%s:%d loadem() add() failure\n", 
  1051. X                __FILE__, __LINE__);
  1052. X            return(!OK);
  1053. X        }
  1054. X        if (Dots == 'Y' || Debug) {
  1055. X            putchar('.');
  1056. X            fflush(stdout);
  1057. X        }
  1058. X    }
  1059. X    putchar('\n');
  1060. X    return(NumberLines);
  1061. X}
  1062. LINE *
  1063. setline(number)
  1064. long number;
  1065. X{
  1066. X    LINE *tmp;
  1067. X    tmp=getline(number);
  1068. X    if (tmp != (LINE *) NULL)  {
  1069. X        CurrentLine = number;
  1070. X        current = tmp;
  1071. X    }
  1072. X
  1073. X    return(tmp);
  1074. X}
  1075. LINE *
  1076. getline(number)
  1077. long number;
  1078. X{
  1079. X    LINE *inc;
  1080. X    long i;
  1081. X    if (number > NumberLines) {
  1082. X        printf("%s-%s: getline(%ld) > NumberLines == %ld\n",
  1083. X            Progname, __FILE__, number, NumberLines);
  1084. X        return((LINE *)NULL);
  1085. X    }
  1086. X    if (number == 0L) 
  1087. X        return(l_start);
  1088. X    for (i=1L, inc=l_start; i<number ; i++, inc=inc->next);
  1089. X    return(inc);
  1090. X}
  1091. printline(number)
  1092. long number;
  1093. X{
  1094. X    LINE *tmp;
  1095. X    if ((tmp=setline(number)) != (LINE *) NULL) {
  1096. X        fputs(tmp->text, stdout);
  1097. X        fflush(stdout);
  1098. X        return(OK);
  1099. X    }
  1100. X    fprintf(stderr, "%s: printline(%ld) Bad line number\n", __FILE__, number);
  1101. X    fflush(stderr);
  1102. X    return(!OK);
  1103. X}
  1104. X
  1105. X
  1106. X
  1107. add(buf, number)
  1108. char *buf;
  1109. long number;
  1110. X{
  1111. X    LINE *new, *temp;
  1112. X    if (Debug) printf("add(%ld)\n", number);
  1113. X    new = (LINE *) malloc(sizeof(LINE) + strlen(buf));
  1114. X    if (number > 0L) {
  1115. X        temp=getline(number);
  1116. X        if (temp == (LINE *) NULL)  {
  1117. X            fprintf(stderr, "%s: add(%ld) bad line number\n",
  1118. X                __FILE__, number);
  1119. X            return(!OK);
  1120. X        }
  1121. X        new -> previous = temp;
  1122. X        if (temp->next != (LINE *) NULL)  {
  1123. X            temp->next->previous = new;
  1124. X            new -> next = temp->next;
  1125. X        } else {
  1126. X            new->next = (LINE *) NULL;
  1127. X            l_end = new;
  1128. X        }
  1129. X        temp -> next = new;
  1130. X    } else {
  1131. X        new -> previous = (LINE *) NULL;
  1132. X        if (NumberLines < 1L) {
  1133. X            new -> next = (LINE *) NULL;
  1134. X            l_end = new;
  1135. X        } else 
  1136. X            new -> next = l_end;
  1137. X
  1138. X        /* Now, blow away anything nasty, still hanging around */
  1139. X        if (l_start != (LINE *) NULL)
  1140. X            free(l_start); 
  1141. X
  1142. X        l_start = new;
  1143. X        current = new;
  1144. X    }
  1145. X    /* make sure line has a newline on the end.. */
  1146. X    if (buf[strlen(buf)-1] != '\n')
  1147. X        strcat(buf, "\n");
  1148. X    strcpy(new->text, buf);
  1149. X    NumberLines++;
  1150. X    current=new;
  1151. X    CurrentLine=NumberLines;
  1152. X    return(OK);
  1153. X}
  1154. subtract(number)
  1155. long number;
  1156. X{
  1157. X    LINE *tmp;
  1158. X    tmp = getline(number);
  1159. X    if (tmp == (LINE *)NULL) {
  1160. X        fprintf(stderr, "%s: subtract(%ld) bad line number\n", 
  1161. X            __FILE__, number);
  1162. X        return(!OK);
  1163. X    }
  1164. X    if (l_end == tmp) {
  1165. X        l_end = l_end -> previous;
  1166. X    }
  1167. X    if (tmp -> previous != (LINE *) NULL) 
  1168. X        tmp -> previous -> next = tmp -> next; 
  1169. X     else {
  1170. X        if (tmp -> next != (LINE *) NULL) {
  1171. X            tmp -> next -> previous = (LINE *) NULL;
  1172. X            l_start = tmp -> next;
  1173. X        }
  1174. X    }
  1175. X
  1176. X    if (tmp -> next != (LINE *) NULL)
  1177. X        tmp -> next -> previous  = tmp -> previous;
  1178. X     else {
  1179. X        if (tmp -> previous != (LINE *) NULL) {
  1180. X            tmp -> previous -> next = (LINE *) NULL;
  1181. X            l_end = tmp -> previous;
  1182. X        }
  1183. X    }
  1184. X    if (NumberLines-- > 1L)
  1185. X        free(tmp);
  1186. X    current=setline(number < NumberLines ? number : NumberLines);
  1187. X    return(current != (LINE *) NULL ? OK : !OK);
  1188. X}
  1189. X    
  1190. replace(number, buf)
  1191. char *buf;
  1192. long number;
  1193. X{
  1194. X    LINE *old, *new;
  1195. X    old=getline(number);
  1196. X    if (old == (LINE *) NULL)  {
  1197. X        fprintf(stderr, "%s: replace(%ld) bad line number\n", __FILE__, number);
  1198. X        return(!OK);
  1199. X    }
  1200. X    new = (LINE *) malloc(sizeof(LINE) + strlen(buf));
  1201. X    new -> previous        = old -> previous;
  1202. X    new -> next        = old -> next;
  1203. X    if (new -> previous != (LINE *) NULL)  
  1204. X        new -> previous -> next = new;
  1205. X    else 
  1206. X        l_start = new;
  1207. X
  1208. X    if (new -> next != (LINE *) NULL)  
  1209. X        new -> next -> previous = new;
  1210. X    else 
  1211. X        l_end = new;
  1212. X
  1213. X    if (STRCHR(buf, '\n') == NULL)
  1214. X        strcat(buf, "\n");
  1215. X    strcpy(new->text, buf);
  1216. X    free(old);
  1217. X    current=setline(number);
  1218. X    return(current != (LINE *) NULL ? OK : !OK );
  1219. X}
  1220. srch_n_replace(number, old_str, new_str, glob)
  1221. long number;
  1222. char *old_str, *new_str;
  1223. char glob;
  1224. X{
  1225. X    LINE *work;
  1226. X    char *p, *b, *buff;
  1227. X    int len_old, cnt=0;
  1228. X    work = getline(number);
  1229. X    if (work == (LINE *) NULL) {
  1230. X        fprintf(stderr, "%s: srch_n_replace(%ld) bad line number\n",
  1231. X            __FILE__, number);
  1232. X        return(!OK);
  1233. X    }
  1234. X    len_old = strlen(old_str);
  1235. X    buff = malloc(MAXREPLACE);
  1236. X    if (buff == NULL)
  1237. X        return(!OK);
  1238. X    p=work->text;
  1239. X    b=buff;
  1240. X    do {
  1241. X        cnt++;
  1242. X        if (*p == *old_str)  {
  1243. X            if (!strncmp(p, old_str, len_old)) {
  1244. X                p += (len_old-1); /* advance past string */
  1245. X                b = strappend(b, new_str);
  1246. X                if (glob == 'N')  {
  1247. X                    p++;
  1248. X                    strcat(b, p);
  1249. X                    break;
  1250. X                }
  1251. X            } else
  1252. X            *(b++) = *p;
  1253. X        } else 
  1254. X            *(b++) = *p;
  1255. X    } while ((*(p++) != '\0') && cnt < MAXREPLACE);
  1256. X    replace(number, buff);
  1257. X    free(buff);
  1258. X    return(OK);
  1259. X}
  1260. saveem(file)
  1261. char *file;
  1262. X{
  1263. X    LINE *work;
  1264. X    int out;
  1265. X    long count=0L;
  1266. X    out = open(file, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  1267. X    if (out < 0) {
  1268. X        fprintf(stderr, "%s: Could not open \"%s\" for writing",
  1269. X            Progname, file);
  1270. X        perror("");
  1271. X        return(!OK);
  1272. X    }
  1273. X    work = l_start;
  1274. X    while (work != (LINE *) NULL && count < NumberLines)  {
  1275. X        count++;
  1276. X        write(out, work->text, strlen(work->text));
  1277. X        work = work-> next;
  1278. X        if (WriteOnQuit != 'Y') putchar('.');
  1279. X    }
  1280. X    close(out);
  1281. X    putchar('\n');
  1282. X    return(OK);
  1283. X}
  1284. END_OF_FILE
  1285. if test 5810 -ne `wc -c <'mem.c'`; then
  1286.     echo shar: \"'mem.c'\" unpacked with wrong size!
  1287. fi
  1288. # end of 'mem.c'
  1289. fi
  1290. if test -f 'multi.c' -a "${1}" != "-c" ; then 
  1291.   echo shar: Will not clobber existing file \"'multi.c'\"
  1292. else
  1293. echo shar: Extracting \"'multi.c'\" \(1593 characters\)
  1294. sed "s/^X//" >'multi.c' <<'END_OF_FILE'
  1295. X
  1296. X/*
  1297. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  1298. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  1299. X *  any maner provided you give credit where credit is due and don't pretend
  1300. X *  you wrote it.
  1301. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  1302. X *  in copyright law that you will never ever forget.
  1303. X */
  1304. X#include "defs.h"
  1305. X#include "externs.h"
  1306. X
  1307. X#define RANGE(x)    (x > 0 && x <= NumberLines)
  1308. static char *Start="Starting line number ";
  1309. static char *End=  "  Ending line number ";
  1310. multi_change()
  1311. X{
  1312. X    long start, end, count;
  1313. X    char *string="for changes :";
  1314. X    fputs(Start, stdout);
  1315. X    fputs(string, stdout);
  1316. X    start=getlnum();
  1317. X    if (!RANGE(start)) 
  1318. X        return(!OK);
  1319. X    fputs(End, stdout);
  1320. X    fputs(string, stdout);
  1321. X    end=getlnum();
  1322. X    if (!RANGE(end))
  1323. X        return(!OK);
  1324. X    for(count = start ; count <= end ; count++) 
  1325. X        change(count);
  1326. X    return(OK);
  1327. X}
  1328. multi_delete()
  1329. X{
  1330. X    long start, end, count;
  1331. X    char *string="to delete : ";
  1332. X    fputs(Start, stdout);
  1333. X    fputs(string, stdout);
  1334. X    start=getlnum();
  1335. X    if (!RANGE(start)) 
  1336. X        return(!OK);
  1337. X    fputs(End, stdout);
  1338. X    fputs(string, stdout);
  1339. X    end=getlnum();
  1340. X    if (!RANGE(end))
  1341. X        return(!OK);
  1342. X    for(count = end ; count >= start ; count--) 
  1343. X        subtract(count);
  1344. X    return(OK);
  1345. X}
  1346. multi_print()
  1347. X{
  1348. X    long start, end, count;
  1349. X    char *string="to be printed : ";
  1350. X    fputs(Start, stdout);
  1351. X    fputs(string, stdout);
  1352. X    start=getlnum();
  1353. X    if (!RANGE(start)) 
  1354. X        return(!OK);
  1355. X    fputs(End, stdout);
  1356. X    fputs(string, stdout);
  1357. X    end=getlnum();
  1358. X    if (!RANGE(end))
  1359. X        return(!OK);
  1360. X    for(count = start ; count <= end ; count++) 
  1361. X        printline(count);
  1362. X    return(OK);
  1363. X}
  1364. END_OF_FILE
  1365. if test 1593 -ne `wc -c <'multi.c'`; then
  1366.     echo shar: \"'multi.c'\" unpacked with wrong size!
  1367. fi
  1368. # end of 'multi.c'
  1369. fi
  1370. if test -f 'stuff.c' -a "${1}" != "-c" ; then 
  1371.   echo shar: Will not clobber existing file \"'stuff.c'\"
  1372. else
  1373. echo shar: Extracting \"'stuff.c'\" \(1773 characters\)
  1374. sed "s/^X//" >'stuff.c' <<'END_OF_FILE'
  1375. X/*
  1376. X * This code copyright 1988 by Doug Davis (doug@letni.lawnet.com) 
  1377. X *  You are free to modify, hack, fold, spindle, or mutlate this code in
  1378. X *  any maner provided you give credit where credit is due and don't pretend
  1379. X *  you wrote it.
  1380. X *  If you do my lawyers (and I have a lot of lawyers) will teach you a lesson
  1381. X *  in copyright law that you will never ever forget.
  1382. X */
  1383. X#include "defs.h"    /* just for the #define of a NULL */
  1384. X#include "externs.h" /* for the strings things. */
  1385. X
  1386. X/* append  s2 unto s1, returning a pointer to the new "end" of s1 */
  1387. char *
  1388. strappend(s1, s2)
  1389. char *s1, *s2;
  1390. X{
  1391. X    register char *p, *r;
  1392. X    p = s1;
  1393. X    r = s2;
  1394. X    do {
  1395. X        *(p++) = *r;
  1396. X    } while ( *(r++) != '\0');
  1397. X    p--;
  1398. X    return(p);
  1399. X}
  1400. X/* return a pointer to the first occurence of s2 in s1 otherwise NULL */
  1401. char *
  1402. strindex(s1, s2)
  1403. char *s1, *s2;
  1404. X{
  1405. X    register char *p, *s;
  1406. X    register int len;
  1407. X    p=s1;
  1408. X    len = strlen(s2);
  1409. X    /* quick test to blow away short lines */
  1410. X    if (len > strlen(s1))
  1411. X        return(NULL);
  1412. X    while ((s=STRCHR(p, *s2)) != NULL) {
  1413. X        if (!strncmp(s, s2, len))  {
  1414. X            return(s);
  1415. X        }
  1416. X        p= (++s);
  1417. X    }
  1418. X    return(NULL);
  1419. X}
  1420. long
  1421. makenum(buf)
  1422. char *buf;
  1423. X{
  1424. X    switch (*buf) {
  1425. X        case '\0':
  1426. X            return(-1L);
  1427. X        break;
  1428. X        case '$':
  1429. X            return(NumberLines);
  1430. X        break;
  1431. X        case '^':
  1432. X            return(1L);
  1433. X        break;
  1434. X        case '0':
  1435. X        case '1':
  1436. X        case '2':
  1437. X        case '3':
  1438. X        case '4':
  1439. X        case '5':
  1440. X        case '6':
  1441. X        case '7':
  1442. X        case '8':
  1443. X        case '9':
  1444. X            return(atol(buf) > 1L ? atol(buf) : 1L);
  1445. X        break;
  1446. X        default:
  1447. X            return(-1L);
  1448. X    }
  1449. X    return(-1L);
  1450. X}
  1451. help()
  1452. X{
  1453. X    register int input, amount;
  1454. X    if ((input = open (HelpName, O_RDONLY)) < 0) {
  1455. X        fprintf(stderr, "%s: Could not open file \"%s\"",
  1456. X            Progname, HelpName);
  1457. X        perror("");
  1458. X        return(!OK);
  1459. X    }
  1460. X    while((amount=read(input, buf, BUFSIZ)) > 0)
  1461. X        write(1, buf, amount);
  1462. X    close(input);
  1463. X    return(OK);
  1464. X}
  1465. END_OF_FILE
  1466. if test 1773 -ne `wc -c <'stuff.c'`; then
  1467.     echo shar: \"'stuff.c'\" unpacked with wrong size!
  1468. fi
  1469. # end of 'stuff.c'
  1470. fi
  1471. echo shar: End of archive 1 \(of 1\).
  1472. cp /dev/null ark1isdone
  1473. MISSING=""
  1474. for I in 1 ; do
  1475.     if test ! -f ark${I}isdone ; then
  1476.     MISSING="${MISSING} ${I}"
  1477.     fi
  1478. done
  1479. if test "${MISSING}" = "" ; then
  1480.     echo You have the archive.
  1481.     echo "Now read the README file and edit the Makefile for your system"
  1482.     rm -f ark[1-9]isdone
  1483. else
  1484.     echo You still need to unpack the following archives:
  1485.     echo "        " ${MISSING}
  1486. fi
  1487. ##  End of shell archive.
  1488. exit 0
  1489.